const path = require('path');
const DataStore = require('../utils/dataStore');
const logger = require('../utils/logger');
const config = require('../config');

/**
 * 家人信息服务
 * 管理家人信息和重要日期
 */
class FamilyService {
  constructor() {
    // 初始化数据存储
    this.dataStore = new DataStore(path.join(__dirname, '../../', config.dataFiles.family));
    this.initialized = false;
  }

  /**
   * 初始化家人信息服务
   */
  async init() {
    try {
      await this.dataStore.init();
      this.initialized = true;
      logger.info('家人信息服务初始化成功');
    } catch (error) {
      logger.error(`家人信息服务初始化失败: ${error.message}`);
      throw error;
    }
  }

  /**
   * 确保服务已初始化
   */
  async ensureInitialized() {
    if (!this.initialized) {
      await this.init();
    }
  }

  /**
   * 获取所有家人信息
   * @returns {Promise<Array>} 家人信息数组
   */
  async getAllFamilyMembers() {
    await this.ensureInitialized();
    return this.dataStore.getAll();
  }

  /**
   * 根据ID获取家人信息
   * @param {string} id - 家人ID
   * @returns {Promise<Object|null>} 家人信息或null
   */
  async getFamilyMemberById(id) {
    await this.ensureInitialized();
    return this.dataStore.getById(id);
  }

  /**
   * 添加家人信息
   * @param {Object} memberData - 家人信息数据
   * @returns {Promise<Object>} 添加的家人信息
   */
  async addFamilyMember(memberData) {
    await this.ensureInitialized();
    
    // 验证必要字段
    if (!memberData.name) {
      throw new Error('家人姓名不能为空');
    }
    
    // 创建家人信息对象
    const member = {
      ...memberData,
      id: this.dataStore.generateId(),
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString()
    };
    
    // 添加到数据存储
    const result = await this.dataStore.add(member);
    logger.info(`已添加家人信息: ${member.name}`);
    return result;
  }

  /**
   * 更新家人信息
   * @param {string} id - 家人ID
   * @param {Object} updates - 更新内容
   * @returns {Promise<Object|null>} 更新后的家人信息或null
   */
  async updateFamilyMember(id, updates) {
    await this.ensureInitialized();
    
    // 更新数据
    const result = await this.dataStore.update(id, updates);
    if (result) {
      logger.info(`已更新家人信息: ${id}`);
    } else {
      logger.warn(`未找到要更新的家人信息: ${id}`);
    }
    return result;
  }

  /**
   * 删除家人信息
   * @param {string} id - 家人ID
   * @returns {Promise<boolean>} 是否成功删除
   */
  async deleteFamilyMember(id) {
    await this.ensureInitialized();
    
    // 删除数据
    const result = await this.dataStore.delete(id);
    if (result) {
      logger.info(`已删除家人信息: ${id}`);
    } else {
      logger.warn(`未找到要删除的家人信息: ${id}`);
    }
    return result;
  }

  /**
   * 搜索家人信息
   * @param {string} query - 搜索关键词
   * @returns {Promise<Array>} 匹配的家人信息数组
   */
  async searchFamilyMembers(query) {
    await this.ensureInitialized();
    
    if (!query) {
      return this.dataStore.getAll();
    }
    
    // 执行搜索
    const searchTerm = query.toLowerCase();
    const results = await this.dataStore.query(member => {
      return (
        (member.name && member.name.toLowerCase().includes(searchTerm)) ||
        (member.relationship && member.relationship.toLowerCase().includes(searchTerm)) ||
        (member.notes && member.notes.toLowerCase().includes(searchTerm))
      );
    });
    
    logger.debug(`家人信息搜索结果: ${results.length} 条记录`);
    return results;
  }

  /**
   * 获取即将到来的重要日期
   * @param {number} days - 未来天数范围
   * @returns {Promise<Array>} 重要日期数组
   */
  async getUpcomingEvents(days = 30) {
    await this.ensureInitialized();
    
    try {
      const allMembers = await this.dataStore.getAll();
      const today = new Date();
      const events = [];
      
      // 设置日期范围
      const endDate = new Date();
      endDate.setDate(today.getDate() + days);
      
      // 处理每个家庭成员
      for (const member of allMembers) {
        // 处理生日
        if (member.birthday) {
          const birthdayEvent = this.processAnnualEvent(
            member.birthday,
            today,
            endDate,
            `${member.name}的生日`,
            'birthday',
            member.id
          );
          if (birthdayEvent) events.push(birthdayEvent);
        }
        
        // 处理结婚纪念日
        if (member.anniversaryDate) {
          const anniversaryEvent = this.processAnnualEvent(
            member.anniversaryDate,
            today,
            endDate,
            `${member.name}的结婚纪念日`,
            'anniversary',
            member.id
          );
          if (anniversaryEvent) events.push(anniversaryEvent);
        }
        
        // 处理其他重要日期
        if (member.importantDates && Array.isArray(member.importantDates)) {
          for (const date of member.importantDates) {
            if (date.date && date.description) {
              const importantEvent = this.processAnnualEvent(
                date.date,
                today,
                endDate,
                `${member.name}: ${date.description}`,
                'important',
                member.id,
                date.id
              );
              if (importantEvent) events.push(importantEvent);
            }
          }
        }
      }
      
      // 按日期排序
      events.sort((a, b) => a.date.getTime() - b.date.getTime());
      
      return events;
    } catch (error) {
      logger.error(`获取即将到来的重要日期失败: ${error.message}`);
      throw error;
    }
  }

  /**
   * 处理年度重复事件
   * @param {string} dateString - 日期字符串
   * @param {Date} today - 今天的日期
   * @param {Date} endDate - 结束日期
   * @param {string} description - 事件描述
   * @param {string} type - 事件类型
   * @param {string} memberId - 家人ID
   * @param {string} eventId - 事件ID（可选）
   * @returns {Object|null} 事件对象或null
   */
  processAnnualEvent(dateString, today, endDate, description, type, memberId, eventId = null) {
    try {
      // 解析原始日期
      const originalDate = new Date(dateString);
      if (isNaN(originalDate.getTime())) {
        return null;
      }
      
      // 创建今年的事件日期
      const thisYearDate = new Date(
        today.getFullYear(),
        originalDate.getMonth(),
        originalDate.getDate()
      );
      
      // 如果今年的日期已过，则使用明年的日期
      let eventDate = thisYearDate;
      if (thisYearDate < today) {
        eventDate = new Date(
          today.getFullYear() + 1,
          originalDate.getMonth(),
          originalDate.getDate()
        );
      }
      
      // 检查是否在指定范围内
      if (eventDate <= endDate) {
        // 计算年龄或周年
        let years = 0;
        if (type === 'birthday') {
          years = eventDate.getFullYear() - originalDate.getFullYear();
        } else if (type === 'anniversary') {
          years = eventDate.getFullYear() - originalDate.getFullYear();
        }
        
        // 创建事件对象
        return {
          id: eventId || `${type}_${memberId}_${originalDate.getTime()}`,
          memberId,
          type,
          date: eventDate,
          description,
          originalDate: originalDate.toISOString(),
          years,
          daysUntil: Math.ceil((eventDate - today) / (1000 * 60 * 60 * 24))
        };
      }
      
      return null;
    } catch (error) {
      logger.error(`处理年度事件失败: ${error.message}`);
      return null;
    }
  }

  /**
   * 添加重要日期到家人信息
   * @param {string} memberId - 家人ID
   * @param {Object} dateInfo - 日期信息
   * @returns {Promise<Object|null>} 更新后的家人信息或null
   */
  async addImportantDate(memberId, dateInfo) {
    await this.ensureInitialized();
    
    try {
      // 获取家人信息
      const member = await this.dataStore.getById(memberId);
      if (!member) {
        throw new Error(`未找到家人信息: ${memberId}`);
      }
      
      // 验证日期信息
      if (!dateInfo.date || !dateInfo.description) {
        throw new Error('日期和描述不能为空');
      }
      
      // 创建重要日期对象
      const newDate = {
        id: this.dataStore.generateId(),
        date: dateInfo.date,
        description: dateInfo.description,
        type: dateInfo.type || 'other',
        createdAt: new Date().toISOString()
      };
      
      // 添加到家人信息
      if (!member.importantDates || !Array.isArray(member.importantDates)) {
        member.importantDates = [];
      }
      member.importantDates.push(newDate);
      
      // 更新家人信息
      const result = await this.dataStore.update(memberId, {
        importantDates: member.importantDates
      });
      
      logger.info(`已添加重要日期: ${dateInfo.description} 到 ${member.name}`);
      return result;
    } catch (error) {
      logger.error(`添加重要日期失败: ${error.message}`);
      throw error;
    }
  }

  /**
   * 删除家人的重要日期
   * @param {string} memberId - 家人ID
   * @param {string} dateId - 日期ID
   * @returns {Promise<Object|null>} 更新后的家人信息或null
   */
  async deleteImportantDate(memberId, dateId) {
    await this.ensureInitialized();
    
    try {
      // 获取家人信息
      const member = await this.dataStore.getById(memberId);
      if (!member) {
        throw new Error(`未找到家人信息: ${memberId}`);
      }
      
      // 检查重要日期是否存在
      if (!member.importantDates || !Array.isArray(member.importantDates)) {
        throw new Error('家人没有重要日期记录');
      }
      
      // 过滤掉要删除的日期
      const initialLength = member.importantDates.length;
      member.importantDates = member.importantDates.filter(date => date.id !== dateId);
      
      if (member.importantDates.length === initialLength) {
        throw new Error(`未找到重要日期: ${dateId}`);
      }
      
      // 更新家人信息
      const result = await this.dataStore.update(memberId, {
        importantDates: member.importantDates
      });
      
      logger.info(`已删除重要日期: ${dateId} 从 ${member.name}`);
      return result;
    } catch (error) {
      logger.error(`删除重要日期失败: ${error.message}`);
      throw error;
    }
  }
}

// 导出单例
module.exports = new FamilyService();